# **********************************************************************
#
# Copyright (c) 2003-2007 ZeroC, Inc. All rights reserved.
#
# This copy of Ice is licensed to you under the terms described in the
# ICE_LICENSE file included in this distribution.
#
# **********************************************************************

# Ice version 3.2.1
# Generated from file `Printer.ice'

import Ice, IcePy, __builtin__

# Start of module Demo
_M_Demo = Ice.openModule('Demo')
__name__ = 'Demo'

if not _M_Demo.__dict__.has_key('BodyStruct'):
    _M_Demo.BodyStruct = Ice.createTempClass()
    class BodyStruct(object):
        def __init__(self, id=0, radius=0.0, posX=0.0, posY=0.0, posZ=0.0):
            self.id = id
            self.radius = radius
            self.posX = posX
            self.posY = posY
            self.posZ = posZ

        def __hash__(self):
            _h = 0
            _h = 5 * _h + __builtin__.hash(self.id)
            _h = 5 * _h + __builtin__.hash(self.radius)
            _h = 5 * _h + __builtin__.hash(self.posX)
            _h = 5 * _h + __builtin__.hash(self.posY)
            _h = 5 * _h + __builtin__.hash(self.posZ)
            return _h % 0x7fffffff

        def __eq__(self, other):
            if not self.id == other.id:
                return False
            if not self.radius == other.radius:
                return False
            if not self.posX == other.posX:
                return False
            if not self.posY == other.posY:
                return False
            if not self.posZ == other.posZ:
                return False
            return True

        def __str__(self):
            return IcePy.stringify(self, _M_Demo._t_BodyStruct)

        __repr__ = __str__

    _M_Demo._t_BodyStruct = IcePy.defineStruct('::Demo::BodyStruct', BodyStruct, (), (
        ('id', (), IcePy._t_int),
        ('radius', (), IcePy._t_double),
        ('posX', (), IcePy._t_double),
        ('posY', (), IcePy._t_double),
        ('posZ', (), IcePy._t_double)
    ))

    _M_Demo.BodyStruct = BodyStruct
    del BodyStruct

if not _M_Demo.__dict__.has_key('_t_bodyStructList'):
    _M_Demo._t_bodyStructList = IcePy.defineSequence('::Demo::bodyStructList', (), _M_Demo._t_BodyStruct)

if not _M_Demo.__dict__.has_key('Printer'):
    _M_Demo.Printer = Ice.createTempClass()
    class Printer(Ice.Object):
        def __init__(self):
            if __builtin__.type(self) == _M_Demo.Printer:
                raise RuntimeError('Demo.Printer is an abstract class')

        def ice_ids(self, current=None):
            return ('::Demo::Printer', '::Ice::Object')

        def ice_id(self, current=None):
            return '::Demo::Printer'

        #
        # Operation signatures.
        #
        # def setNumberOfBodies(self, numOfBodies, current=None):
        # def setLowerLimitMass(self, lowLMass, current=None):
        # def setUpperLimitMass(self, uppLMass, current=None):
        # def setLowerLimitRadii(self, lowLRadii, current=None):
        # def setUpperLimitRadii(self, uppLRadii, current=None):
        # def setMassCentralBody(self, massCBody, current=None):
        # def setSpaceCircumferenceLowerLimit(self, spaceCirLowL, current=None):
        # def setSpaceCircumferenceUpperLimit(self, spaceCirUppL, current=None):
        # def setDeltaT(self, deltaT, current=None):
        # def initRandomMultiBodySystem(self, current=None):
        # def calcOneStep(self, current=None):
        # def getBodyStructList(self, current=None):

        def __str__(self):
            return IcePy.stringify(self, _M_Demo._t_Printer)

        __repr__ = __str__

    _M_Demo.PrinterPrx = Ice.createTempClass()
    class PrinterPrx(Ice.ObjectPrx):

        def setNumberOfBodies(self, numOfBodies, _ctx=None):
            return _M_Demo.Printer._op_setNumberOfBodies.invoke(self, (numOfBodies, ), _ctx)

        def setLowerLimitMass(self, lowLMass, _ctx=None):
            return _M_Demo.Printer._op_setLowerLimitMass.invoke(self, (lowLMass, ), _ctx)

        def setUpperLimitMass(self, uppLMass, _ctx=None):
            return _M_Demo.Printer._op_setUpperLimitMass.invoke(self, (uppLMass, ), _ctx)

        def setLowerLimitRadii(self, lowLRadii, _ctx=None):
            return _M_Demo.Printer._op_setLowerLimitRadii.invoke(self, (lowLRadii, ), _ctx)

        def setUpperLimitRadii(self, uppLRadii, _ctx=None):
            return _M_Demo.Printer._op_setUpperLimitRadii.invoke(self, (uppLRadii, ), _ctx)

        def setMassCentralBody(self, massCBody, _ctx=None):
            return _M_Demo.Printer._op_setMassCentralBody.invoke(self, (massCBody, ), _ctx)

        def setSpaceCircumferenceLowerLimit(self, spaceCirLowL, _ctx=None):
            return _M_Demo.Printer._op_setSpaceCircumferenceLowerLimit.invoke(self, (spaceCirLowL, ), _ctx)

        def setSpaceCircumferenceUpperLimit(self, spaceCirUppL, _ctx=None):
            return _M_Demo.Printer._op_setSpaceCircumferenceUpperLimit.invoke(self, (spaceCirUppL, ), _ctx)

        def setDeltaT(self, deltaT, _ctx=None):
            return _M_Demo.Printer._op_setDeltaT.invoke(self, (deltaT, ), _ctx)

        def initRandomMultiBodySystem(self, _ctx=None):
            return _M_Demo.Printer._op_initRandomMultiBodySystem.invoke(self, (), _ctx)

        def calcOneStep(self, _ctx=None):
            return _M_Demo.Printer._op_calcOneStep.invoke(self, (), _ctx)

        def getBodyStructList(self, _ctx=None):
            return _M_Demo.Printer._op_getBodyStructList.invoke(self, (), _ctx)

        def checkedCast(proxy, facetOrCtx=None, _ctx=None):
            return _M_Demo.PrinterPrx.ice_checkedCast(proxy, '::Demo::Printer', facetOrCtx, _ctx)
        checkedCast = staticmethod(checkedCast)

        def uncheckedCast(proxy, facet=None):
            return _M_Demo.PrinterPrx.ice_uncheckedCast(proxy, facet)
        uncheckedCast = staticmethod(uncheckedCast)

    _M_Demo._t_PrinterPrx = IcePy.defineProxy('::Demo::Printer', PrinterPrx)

    _M_Demo._t_Printer = IcePy.defineClass('::Demo::Printer', Printer, (), True, None, (), ())
    Printer.ice_type = _M_Demo._t_Printer

    Printer._op_setNumberOfBodies = IcePy.Operation('setNumberOfBodies', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), IcePy._t_int),), (), None, ())
    Printer._op_setLowerLimitMass = IcePy.Operation('setLowerLimitMass', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), IcePy._t_int),), (), None, ())
    Printer._op_setUpperLimitMass = IcePy.Operation('setUpperLimitMass', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), IcePy._t_int),), (), None, ())
    Printer._op_setLowerLimitRadii = IcePy.Operation('setLowerLimitRadii', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), IcePy._t_int),), (), None, ())
    Printer._op_setUpperLimitRadii = IcePy.Operation('setUpperLimitRadii', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), IcePy._t_int),), (), None, ())
    Printer._op_setMassCentralBody = IcePy.Operation('setMassCentralBody', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), IcePy._t_double),), (), None, ())
    Printer._op_setSpaceCircumferenceLowerLimit = IcePy.Operation('setSpaceCircumferenceLowerLimit', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), IcePy._t_int),), (), None, ())
    Printer._op_setSpaceCircumferenceUpperLimit = IcePy.Operation('setSpaceCircumferenceUpperLimit', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), IcePy._t_int),), (), None, ())
    Printer._op_setDeltaT = IcePy.Operation('setDeltaT', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (((), IcePy._t_int),), (), None, ())
    Printer._op_initRandomMultiBodySystem = IcePy.Operation('initRandomMultiBodySystem', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), None, ())
    Printer._op_calcOneStep = IcePy.Operation('calcOneStep', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), IcePy._t_int, ())
    Printer._op_getBodyStructList = IcePy.Operation('getBodyStructList', Ice.OperationMode.Normal, Ice.OperationMode.Normal, False, (), (), (), _M_Demo._t_bodyStructList, ())

    _M_Demo.Printer = Printer
    del Printer

    _M_Demo.PrinterPrx = PrinterPrx
    del PrinterPrx

# End of module Demo
